#ifndef __WIZ_ARCHIVE_BASE_HPP__SHANHAOBO_19800429__
#define __WIZ_ARCHIVE_BASE_HPP__SHANHAOBO_19800429__

#include "./WizArchiveForwardDeclare.hpp"

namespace Wiz
{
    namespace Archive
    {
        namespace Version
        {
            class Type
            {
            private:
                ::Wiz::Archive::VerNum::Type m_VerNum;

            public:
                Type() : m_VerNum(0)
                {
                }
                explicit Type(::Wiz::Archive::VerNum::In InVerNum) : m_VerNum(InVerNum)
                {
                }
                Type(const Type & InVer) : m_VerNum(InVer.m_VerNum)
                {
                }
                Type& operator=(const Type & rhs)
                {
                    m_VerNum = rhs.m_VerNum;

                    return *this;
                }

                operator ::Wiz::Archive::VerNum::Type() const
                {
                    return m_VerNum;
                }

                operator ::Wiz::Archive::VerNum::Type&()
                {
                    return m_VerNum;
                }     

                bool operator==(const Type & rhs) const
                {
                    return m_VerNum == rhs.m_VerNum;
                } 

                bool operator<(const Type & rhs) const
                {
                    return m_VerNum < rhs.m_VerNum;
                }   
            };
        } /// end of namespace Version

        namespace ClassID
        {
            class Type
            {
            private:
                ::Wiz::Int16::Type m_ID;
            public:
                Type() : m_ID(0)
                {
                }

                explicit Type(const int InID) : m_ID(InID)
                {
                }

                explicit Type(const std::size_t InID) : m_ID(InID)
                {
                }

                Type(const Type & InID) : m_ID(InID.m_ID)
                {
                }

                Type & operator=(const Type & rhs)
                {
                    m_ID = rhs.m_ID;
                    return *this;
                }

                operator int () const
                {
                    return m_ID;
                }

                operator ::Wiz::Int16::Type &()
                {
                    return m_ID;
                }

                bool operator==(const Type & rhs) const
                {
                    return m_ID == rhs.m_ID;
                }

                bool operator<(const Type & rhs) const
                {
                    return m_ID < rhs.m_ID;
                }   
            };
        } /// end of namespace ClassID

        namespace ObjectID
        {
            class Type
            {
            private:
                ::Wiz::UInt32::Type m_ID;

            public:
                Type() : m_ID(0)
                {
                }

                explicit Type(const int InID) : m_ID(InID)
                {
                }

                explicit Type(const std::size_t InID) : m_ID(InID)
                {
                }

                Type(const Type & InID) : m_ID(InID.m_ID)
                {
                }

                Type & operator=(const Type & rhs)
                {
                    m_ID = rhs.m_ID;
                    return *this;
                }

                operator ::Wiz::UInt32::Type () const
                {
                    return m_ID;
                }

                operator ::Wiz::UInt32::Type &()
                {
                    return m_ID;
                }

                bool operator==(const Type & rhs) const
                {
                    return m_ID == rhs.m_ID;
                }

                bool operator<(const Type & rhs) const
                {
                    return m_ID < rhs.m_ID;
                }   
            };
        } /// end of namespace ClassID

        /// Remove Duplicate
        namespace RmDup
        {
            struct Type
            {
                ::Wiz::Bool::Type m_Enable;

                explicit Type(::Wiz::Bool::In InEnable = false)
                    : m_Enable(InEnable)
                {};
                Type(const Type & InEnable)
                    : m_Enable(InEnable.m_Enable)
                {}
                operator bool () const
                {
                    return m_Enable;
                };
                operator bool & ()
                {
                    return m_Enable;
                };
                Type & operator=(::Wiz::Bool::In InEnable)
                {
                    m_Enable = InEnable;
                    return *this;
                }
                ::Wiz::Bool::Type operator==(const Type & rhs) const
                {
                    return m_Enable == rhs.m_Enable;
                }
                ::Wiz::Bool::Type operator==(::Wiz::Bool::In rhs) const
                {
                    return m_Enable == rhs;
                }
                Type & operator=(const Type & rhs)
                {
                    m_Enable = rhs.m_Enable;
                    return *this;
                }
            };
        } /// end of namespace RmDup

        namespace ClassName
        {
            struct Type : private ::Wiz::Noncopyable::Type
            {
                char *m_NamePtr;

                operator const char * & () const
                {
                    return const_cast<const char * &>(m_NamePtr);
                }
                operator char * ()
                {
                    return m_NamePtr;
                }
                explicit Type(const char *key_) : m_NamePtr(const_cast<char *>(key_))
                {
                }
                explicit Type(char *key_) : m_NamePtr(key_)
                {
                }
                Type & operator=(const Type & rhs)
                {
                    m_NamePtr = rhs.m_NamePtr;
                    return *this;
                }
            };
        } /// end of namespace ClassName
    } /// end of namespace Archive
} /// end of namespace Wiz

#endif /*__WIZ_ARCHIVE_BASE_HPP__SHANHAOBO_19800429__*/
